/**
 * ajax配置
 */
$.ajaxSetup({
    cache: false,
    complete: function (XMLHttpRequest, textStatus) {
        js.modal.closeLoading();
        if (textStatus === "parsererror") {
            js.modal.confirm("登录超时，请重新登录", function () {
                window.top.location.href = "/";
            });
        }
    }
});

/**
 * 消息状态码
 */
let web_status = {
    SUCCESS: "SUCCESS",
    FAIL: "ERROR"
};

/**
 * 弹窗状态码
 */
let alertStatus = {
    SUCCESS: 1,
    FAIL: 2,
    WARNING: 3
};

/**
 * toastr 插件配置
 */
toastr.options = {
    closeButton: false, // 是否显示关闭按钮（提示框右上角关闭按钮）
    debug: false, //是否为调试
    progressBar: false, // 是否显示进度条（设置关闭的超时时间进度条）
    positionClass: "toast-top-right", // 消息框在页面显示的位置
    /*
      toast-top-left  顶端左边
      toast-top-right    顶端右边
      toast-top-center  顶端中间
      toast-top-full-width 顶端，宽度铺满整个屏幕
      toast-botton-right
      toast-bottom-left
      toast-bottom-center
      toast-bottom-full-width
     */
    onclick: null, // 点击消息框自定义事件
    showDuration: "200", // 显示动作时间
    hideDuration: "200", // 隐藏动作时间
    timeOut: "1500", // 自动关闭超时时间
    extendedTimeOut: "1000",
    showEasing: "swing",
    hideEasing: "linear",
    showMethod: "fadeIn",
    hideMethod: "fadeOut"
};

/**
 * 设置 bootBox 中文
 */
bootbox.setLocale("zh_CN");

let js = {
    /** 计算表格所用高度 */
    getWindowHeight: function () {
        return $(window).height() - $(".content-header").height() - $(".box-header").height() - 80;
    },
    /** 数组去重 */
    deduplication: function (arr, prop) {
        if (prop) {
            let obj = {};
            return arr.filter( item => obj.hasOwnProperty(typeof item[prop] + item[prop].toString().toLowerCase()) ? false : (obj[typeof item[prop] + item[prop].toString().toLowerCase()] = true) );
        } else {
            return arr.map(item => item.toLowerCase()).filter( (item, index, self) => {return self.indexOf(item) === index} );
        }
    },
    /**
     * 判断字符串是否为空
     * @param value 字符串
     * @returns {boolean} 是否为空
     */
    isEmpty: function (value) {
        return value == null || this.trim(value) === "";
    },
    /**
     * 判断字符串是否不为空
     * @param value 字符串
     * @returns {boolean} 是否不为空
     */
    isNotEmpty: function (value) {
        return !js.isEmpty(value);
    },
    /**
     * 字符串去空
     * @param value 字符串
     * @returns {string} 去空后字符串， 如果为空返回 ''
     */
    trim: function (value) {
        if (value == null) {
            return "";
        }
        return value.toString().replace(/(^\s*)|(\s*$)|\r|\n/g, "");
    },
    /**
     * 获取随机数
     * @param min 最小值
     * @param max 最大值
     * @returns {number} 随机数
     */
    random: function (min, max) {
        return Math.floor((Math.random() * max) + min);
    },
    /**
     * 计算日期天数差
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @returns {number} 返回相差天数
     */
    diffDay: function (startDate, endDate) {
        let s = new Date(Date.parse(startDate.replace(/-/g, "/")));
        let e = new Date(Date.parse(endDate.replace(/-/g, "/")));
        let diffMilli = e.getTime() - s.getTime();//时间差的毫秒数
        let diffDay = diffMilli / (24 * 3600 * 1000);//计算出相差天数
        return diffDay + 1;
    },
    /**
     * 获取日期 当前日期基础之上加上day
     * @param day 整数天数， 如果为负则为之前的日期
     * @returns {*}
     */
    getDate: function (day) {
        let currentDate = new Date();
        currentDate.setDate(currentDate.getDate() + day);
        return currentDate.format('yyyy-MM-dd');
    },
    /**
     * 获取form下所有的字段，转换为json对象
     * @param formId
     */
    formToJSON: function (formId) {
        let json = {};
        $.each($("#" + formId).serializeArray(), function (i, field) {
            json[field.name] = field.value;
        });
        return json;
    },
    /**
     * onclick 传JSON对象
     */
    jsonStringify: function(row){
        return JSON.stringify(row).replace(/"/g,'&quot;');
    },
    /** 数组转字符串 */
    arrayToString: function (arr, separate) {
        return arr.reduce((x, y) => x + separate + y);
    },
    /**
     * jquery goUp 插件封装
     */
    goTop: function () {
        $.goup({
            trigger: 100,
            bottomOffset: -20,
            locationOffset: 20,
            // title: '返回顶部',
            // titleAsText: true
        });
    },
    /**
     * 自动补足插件封装
     * @param formId 表单ID
     * @param data 数据
     * @param option 配置信息
     */
    autoComplete: function (formId, data, option) {
        let defaults = {
            max: 5,                 // 列表里的条目数
            minChars: 0,            // 自动完成激活之前填入的最小字符
            scrollHeight: 300,      // 提示的高度，溢出显示滚动条
            matchContains: true,    // 包含匹配，就是data参数里的数据，是否只要包含文本框里的数据就显示
            noRecord: '',
            autoFill: false         // 自动填充
        };
        let options = $.extend(defaults, options);
        $("#" + formId).autocomplete(data, options);
    },
    /**
     * 回车键
     * @param id 触发 click 标签ID
     */
    enter: function (id) {
        $("body").keydown(function (event) {
            if (event.keyCode === 13) {//keyCode=13是回车键
                $("#" + id).click();
            }
        });
    },
    /**
     * jquery ajax 请求
     */
    ajax: function (options) {
        let defaults = {
            url: '',
            type: 'post',
            traditional: true,            // 阻止深度序列化， 使参数可以使用数组
            dataType: 'json',
            contentType: "application/x-www-form-urlencoded",
            data: {},
            async: true,                // 异步执行
            success: function (result) {
                if (result.type === web_status.SUCCESS) {
                    js.modal.success(result.msg);
                } else {
                    js.modal.warning(result.msg);
                }
            },
            error: function () {
                js.modal.fail();
            }
        };
        js.modal.loading("处理中，请稍候...");
        let opt = $.extend(defaults, options);
        $.ajax(opt);
    },
    /**
     * ajax post 请求
     */
    post: function (options) {
        js.ajax(options);
    },
    /**
     * ajax get 请求
     */
    get: function (options) {
        let defaults = {
            type: 'get'
        };
        let opt = $.extend(defaults, options);
        js.ajax(opt);
    },
    /**
     * 带确认提示的 post 请求
     */
    confirmPost: function (options) {
        js.modal.confirm(options.content, function () {
            js.post(options);
        });
    },
    /**
     * 带确认提示的 get 请求
     */
    confirmGet: function (options) {
        js.confirm(options.content, function () {
            js.get(options);
        });
    },
    /**
     * 使用 html5 FormData 提交请求
     */
    submit: function (options) {
        let defaults = {
            processData: false,
            contentType: false
        };
        let opt = $.extend(defaults, options);
        js.post(opt);
    },
    /**
     * 带确认提示的 html5 FormData 请求
     */
    confirmSubmit: function (options) {
        js.modal.confirm(options.content, function () {
            js.submit(options);
        });
    },
    /**
     * 需验证的 html5 FormData 提交
     */
    validSubmit: function (options) {
        if (js.validate.isValid(options.formId)) {
            js.submit(options);
        }
    },
    modal: {
        /**
         * 消息提示模态框
         * @param content 消息内容
         * @param type 消息类型
         */
        msg: function (content, type) {
            switch (type) {
                case alertStatus.SUCCESS:
                    toastr.success(content);
                    break;
                case alertStatus.FAIL:
                    toastr.error(content);
                    break;
                case alertStatus.WARNING:
                    toastr.warning(content);
                    break;
                default:
                    toastr.info(content);
            }
        },
        /**
         * 错误提示模态框
         * @param content 提示内容（可省）
         */
        fail: function (content) {
            js.modal.msg(content ? content : '系统错误！', alertStatus.FAIL);
        },
        /**
         * 错误提示模态框
         * @param content 提示内容（可省）
         */
        establishFail: function (content) {
            js.modal.msg(content ? content : '系统错误！', alertStatus.FAIL);
        },
        /**
         * 成功提示模态框
         * @param content 提示内容（可省）
         */
        success: function (content) {
            js.modal.msg(content ? content : '操作成功！', alertStatus.SUCCESS);
        },
        /**
         * 警告提示模态框
         * @param content 提示内容（可省）
         */
        warning: function (content) {
            js.modal.msg(content ? content : '操作失败！', alertStatus.WARNING);
        },
        /**
         * 打开模态框
         * @param id 标签ID
         */
        open: function (id) {
            $("#" + id).modal('show');
        },
        /**
         * 模态框打开事件
         * @param id 标签ID
         * @param callback 回调方法
         */
        openEvent: function (id, callback) {
            $("#" + id).on('shown.bs.modal', function () {
                callback();
            });
        },
        /**
         * 隐藏模态框
         * @param id 标签ID
         */
        hide: function (id) {
            $("#" + id).modal('hide');
        },
        /**
         * 隐藏模态框触发事件
         * @param id 标签ID
         * @param callback 回调方法
         */
        hideEvent: function (id, callback) {
            $("#" + id).on('hide.bs.modal', function () {
                callback();
            });
        },
        /**
         * 打开遮罩层
         * @param message 提示内容
         */
        loading: function (message) {
            $.blockUI({message: '<div class="loaderbox"><div class="loading-activity"></div> ' + message + '</div>'});
        },
        /**
         * 关闭遮罩层
         */
        closeLoading: function () {
            setTimeout(function () {
                $.unblockUI();
            }, 50);
        },
        /**
         * 带确认按钮模态框
         * @param content 提示内容
         * @param callBack 回调方法
         */
        confirm: function (content, callBack) {
            bootbox.confirm(content, function (result) {
                if (result) {
                    callBack();
                }
            });
        },
        /** alert 提示框 */
        alert: function (content) {
            bootbox.alert(content);
        },
        /** 带输入的提示框， result为输入字符串 */
        prompt: function (content, callBack) {
            bootbox.prompt(content, function (result) {
                callBack(result);
            });
        }
    },
    /**
     * 重置表单
     * @param formId 表单ID
     * @param lock 是否锁定表单
     */
    reset: function (formId, lock) {
        $("#" + formId)[0].reset();
        $("#" + formId).find("input[type='hidden']").val('');
        if (lock) {
            $("#" + formId).css("pointer-events", 'none');
        }
    },
    /**
     * 获取选中复选框项
     * @param name 复选框 name 属性
     * @returns {string} 使用逗号分隔的选中项的值
     */
    selectCheckeds: function (name) {
        let checkeds = "";
        $('input:checkbox[name="' + name + '"]:checked').each(function (i) {
            if (0 === i) {
                checkeds = $(this).val();
            } else {
                checkeds += ("," + $(this).val());
            }
        });
        return checkeds;
    },
    /**
     * 判断页面select标签被选中数量
     * @returns {number}
     */
    selectedCount: function () {
        let i = 0;
        $(".select2").each(function () {
            if ($(this).val()) {
                i++;
            }
        });
        return i;
    },
    /**
     * 判断页面checkbox标签被选中数量
     * @returns {number}
     */
    checkedCount: function (name) {
        let i = 0;
        $('input:checkbox[name="' + name + '"]:checked').each(function () {
            if ($(this).val()) {
                i++;
            }
        });
        return i;
    },
    /**
     * 解除FROM锁定
     * @param formId 表单ID
     */
    unlock: function (formId) {
        $("#" + formId).css("pointer-events", '');
    },
    validate: {
        /**
         * 验证初始化
         * @param formId 表单ID
         * @param option 验证配置信息
         */
        init: function (formId, option) {
            let _option = {
                feedbackIcons: {
                    valid: 'glyphicon glyphicon-ok',
                    invalid: 'glyphicon glyphicon-remove',
                    validating: 'glyphicon glyphicon-refresh'
                }
            };
            $("#" + formId).bootstrapValidator($.extend({}, _option, option)).on('success.form.bv', function (e) { e.preventDefault(); });
        },
        /**
         * 验证表单
         */
        validing: function (formId) {
            $("#" + formId).bootstrapValidator('validate');
        },
        /**
         * 判断表单验证是否成功
         * @returns {*}
         */
        isValid: function (formId) {
            $("#" + formId).bootstrapValidator('validate');
            return $("#" + formId).data('bootstrapValidator').isValid();
        },
        /**
         * 重置表单
         */
        reset: function (formId) {
            $("#" + formId).data('bootstrapValidator').resetForm();
        },
        destroy: function (formId) {
            $("#" + formId).data('bootstrapValidator').destroy();
            $("#" + formId).data('bootstrapValidator', null);
        }
    },
    table: {
        /**
         * 初始化表格
         * @param options 配置信息
         */
        init: function (options) {
            let defaults = {
                id: "bootstrap-table",                              // table标签的 id 属性， 默认bootstrap-table
                url: '',                                            // 请求后台的URL（*）
                type: 0,                                            // 0 代表bootstrapTable 1代表bootstrapTreeTable
                contentType: "application/x-www-form-urlencoded",   // 编码类型
                method: 'post',                                     // 请求方式（*）
                cache: false,                                       // 是否使用缓存
                height: undefined,                                  // 表格的高度，启用表的固定标题
                stickyHeader: true,                                 // 粘性标题,默认false
                stickyHeaderOffsetY: '0px',                         // 粘性标题Y轴偏移
                striped: true,                                      // 是否隔行变色
                sortable: false,                                    // 是否启用排序
                sortStable: false,                                  // 设置为 true 将获得稳定的排序
                sortName: '',                                       // 排序列名称
                sortOrder: 'asc',                                   // 排序方式  asc 或者 desc
                pagination: true,                                   // 是否显示分页
                paginationVAlign: 'bottom',                           // 指示如何垂直对齐分页。'top', 'bottom', 'both'
                pageNumber: 1,                                      // 默认第一页
                pageSize: 300,                                       // 每页的记录行数
                pageList: [10, 15, 25, 50, 100, 300],               // 可供选择的每页的行数
                firstLoad: true,                                    // 是否首次请求加载数据，对于数据较大可以配置false
                escape: false,                                      // 转义HTML字符串
                showFooter: false,                                  // 是否显示列脚
                iconSize: 'outline',                                 // 图标大小：undefined默认的按钮尺寸 xs超小按钮sm小按钮lg大按钮
                toolbar: '#toolbar',                                 // 指定工作栏
                sidePagination: 'server',                            // server启用服务端分页client客户端分页
                search: false,                                      // 是否显示搜索框功能
                searchText: '',                                      // 搜索框初始显示的内容，默认为空
                showSearch: false,                                  // 是否显示检索信息
                showPageGo: false,                             		 // 是否显示跳转页
                showRefresh: false,                                 // 是否显示刷新按钮
                showToggle: false,                                  // 切换试图（table/card）按钮
                showColumns: false,                                  // 是否显示隐藏某列下拉框
                showExport: true,                                   // 是否支持导出文件
                exportDataType: 'basic',                              //'basic':当前页的数据, 'all':全部的数据, 'selected':选中的数据
                buttonsAlign: "right",                               //按钮位置
                exportTypes: ['csv', 'txt', 'sql', 'doc', 'excel', 'xlsx', 'pdf'],  //导出文件类型，[ 'csv', 'txt', 'sql', 'doc', 'excel', 'xlsx', 'pdf']
                uniqueId: undefined,                               // 唯一的标识符
                clickToSelect: false,		                		// 是否启用点击选中行
                detailView: false,                                 // 是否启用显示细节视图
                rememberSelected: false,                           // 启用翻页记住前面的选择
                fixedColumns: false,                               // 是否启用冻结列（左侧）
                fixedNumber: 0,                                     // 列冻结的个数（左侧）
                rightFixedColumns: false,                          // 是否启用冻结列（右侧）
                rightFixedNumber: 0,                                // 列冻结的个数（右侧）
                onReorderRow: undefined,                           // 当拖拽结束后处理函数
                queryForm: 'queryForm',                             // 条件查询表单
                queryData: {},                                      // 查询条件
                queryParams: js.table.queryParams,                  // 传递参数（*）
                rowStyle: {},                                       // 通过自定义函数设置行样式
                responseHandler: js.table.responseHandler,          // 在加载服务器发送来的数据之前处理函数
                onLoadSuccess: js.table.onLoadSuccess,              // 当所有数据被加载时触发处理函数
                onClickRow: undefined,                             // 点击某行触发的事件
                onDblClickRow: undefined,                          // 双击某行触发的事件
                onClickCell: undefined,                            // 单击某格触发的事件
                onDblClickCell: undefined,                         // 双击某格触发的事件
                onExpandRow: undefined,                            // 行展开
                columns: undefined,                                // 显示列信息（*）
                exportOptions: undefined,                          // 前端导出忽略列索引
                detailFormatter: undefined                  // 在行下面展示其他数据列表
            };
            let opt = $.extend(defaults, options);
            return $("#" + opt.id).bootstrapTable(opt);
        },
        // 查询条件
        queryParams: function (params) {
            let curParams = {
                // 传递参数查询参数
                pageSize: params.limit,
                pageNum: params.offset / params.limit + 1,
                sort: params.sort,
                order: params.order
            };
            return $.extend(curParams, this.queryData, js.formToJSON(this.queryForm));
        },
        // 请求获取数据后处理回调函数
        responseHandler: function (res) {
            if (res.type === "SUCCESS") {
                return res.data;
            }
            js.modal.warning(res.msg);
            return {rows: [], total: 0};
        },
        // 当所有数据被加载时触发
        onLoadSuccess: function (data) {
            if (this.stickyHeader) {
                $("#"+this.id).parents(".fixed-table-body").first().scroll(function(){
                    $(this).find('#bootstrap-table-sticky-header-sticky-header-container').css('transform', 'translateX(-' + $(this).scrollLeft() + 'px)');
                });
            }
            js.modal.closeLoading();
        },
        /**
         * 搜索
         * @param table 表格
         * @param formId 参数
         */
        search: function (table) {
            let p = table.bootstrapTable('getOptions');
            p.queryParams = function (params) {
                let search = js.formToJSON(p.queryForm);
                // let search = $("#"+p.queryForm).serializeObject();

                search.pageSize = params.limit;
                search.pageNum = params.offset / params.limit + 1;
                search.sort = params.sort;
                search.order = params.order;
                return $.extend(search, p.queryData);
            };
            table.bootstrapTable('refresh', p);
        },
        /**
         * 表格刷新
         */
        refresh: function (table) {
            table.bootstrapTable('refresh', {
                silent: true
            });
        },
        /**
         * 表格刷新
         * @param table
         * @param options
         */
        refreshOption: function (table, options) {
            table.bootstrapTable('refreshOptions', options);
        },
        /**
         * 表格销毁
         */
        destroy: function (table) {
            table.bootstrapTable('destroy');
        },
        /**
         * 获取选中行 数据为 field 的数组
         */
        selectColumns: function (table, field) {
            return $.map(table.bootstrapTable('getSelections'), function (row) {
                return row[field];
            });
        },
        /**
         * 获取选中行
         */
        selectRows: function (table) {
            return table.bootstrapTable('getSelections');
        },
        /**
         * 获取未选中行 数据为 field 的数组
         */
        unSelectColumns: function (table, field) {
            let selectDate = this.selectColumns(table, field);
            let allDate = $.map(table.bootstrapTable('getData'), function (row) {
                return row[field];
            });
            return allDate.filter(function (element) {
                return selectDate.indexOf(element) === -1;
            });
        },
        /**
         * 显示表格指定列
         */
        showColumn: function (table, column) {
            table.bootstrapTable('showColumn', column);
        },
        /**
         * 隐藏表格指定列
         */
        hideColumn: function (table, column) {
            table.bootstrapTable('hideColumn', column);
        },
        /**
         * 表格刷新,并更换URL
         */
        jump: function (table, url) {
            table.bootstrapTable('refreshOptions', {
                url: url
            });
        },
        /** 合并行 */
        merge: function (table, data, primary, ...fields) {
            let map = {};
            let rowIndex = 0;
            for (let row of data.rows) {
                for (let key in row) {
                    if (key === primary) {
                        if (row[key]) {
                            if (map.hasOwnProperty("$$" + row[key])) {
                                map["$$" + row[key]] = +map["$$" + row[key]] + 1;
                            } else {
                                map["$$" + row[key]] = 1;
                            }
                            break;
                        } else {
                            map["$$" + row[key] + rowIndex] = 1;
                        }
                    }
                }
                rowIndex++;
            }
            let index = 0;
            for (let key in map) {
                for (let field of fields) {
                    table.bootstrapTable("mergeCells", {index: index, field: field, rowspan: +map[key]})
                }
                index += +map[key];
            }
        },
/** 加载数据 */
load: function (table, data) {
    table.bootstrapTable('load', data);
}
},
treeTable: {
    /**
     * 初始化表格
     */
    init: function (options) {
        let defaults = {
            id: "bootstrap-tree-table",
            code: "id",                                   // 用于设置父子关系
            parentCode: "pid",                             // 用于设置父子关系
            type: 'post',                                       // 请求方式（*）
            url: undefined,                                    // 请求后台的URL（*）
            data: undefined,                                   // 无url时用于渲染的数据
            ajaxParams: {},                                     // 请求数据的ajax的data属性
            rootIdValue: null,                                  // 设置指定根节点id值
            height: 0,                                          // 表格树的高度
            expandColumn: 0,                                    // 在哪一列上面显示展开按钮
            striped: false,                                     // 是否显示行间隔色
            bordered: true,                                     // 是否显示边框
            toolbar: "toolbar",                                 // 指定工作栏
            showSearch: false,                                  // 是否显示检索信息
            showRefresh: false,                                 // 是否显示刷新按钮
            showColumns: false,                                 // 是否显示隐藏某列下拉框
            expandAll: false,                                    // 是否全部展开
            expandFirst: true,                                  // 是否默认第一级展开--expandAll为false时生效
            columns: undefined,                                 // 显示列信息（*）
            responseHandler: js.treeTable.responseHandler        // 当所有数据被加载时触发处理函数
        };
        let opt = $.extend(defaults, options);
        return $('#' + opt.id).bootstrapTreeTable(opt);
    },
    /**
     * 条件查询
     * @param treeTable
     * @param formId
     */
    search: function (treeTable, formId) {
        let currentId = $("#queryForm").length > 0 ? "queryForm" : formId;
        let params = js.formToJSON(currentId);
        treeTable.bootstrapTreeTable('refresh', params);
    },
    /**
     * 刷新
     * @param treeTable
     */
    refresh: function (treeTable) {
        treeTable.bootstrapTreeTable('refresh');
    },
    /**
     * 查询表格树指定列值
     * @param treeTable
     * @param column
     * @returns {Array}
     */
    selectColumns: function (treeTable, column) {
        let rows = $.map(treeTable.bootstrapTreeTable('getSelections'), function (row) {
            return row[column];
        });
        return rows.distinct();
    },
    /**
     * 请求获取数据后处理回调函数，校验异常状态提醒
     * @param data
     * @returns {*}
     */
    responseHandler: function (data) {
        return data;
    }
},
tree: {
    /**
     * 初始化树插件
     * @param options 配置信息
     */
    init: function (options) {
        let defaults = {
            id: 'id',
            async: {
                enable: true,                                                   // 采用异步加载
                dataFilter: js.tree.ajaxDataFilter,                              // 预处理数据
                url: '',                                                        // url
                dataType: "json",                                               // 数据类型
                type: "get"                                                     // 请求方式
            },
            check: {
                enable: true,                                                 // 是否显示多选框
                chkStyle: 'checkbox',
                chkboxType: {"Y": "", "N": ""},                                // 父子节点的关联关系   Y 属性定义 checkbox 被勾选后的情况；N 属性定义 checkbox 取消勾选后的情况； "p" 表示操作会影响父级节点； "s" 表示操作会影响子级节点。
                radioType: "all"
            },
            edit: {
                drag: {
                    isCopy: false,                                              // 是否可以复制
                    autoOpenTime: 0,                                            // 自动打开折叠节点延迟时间
                    minMoveSize: 10                                             // 最少移动像素距离开启
                },
                enable: false                                                   // 开启拖拽
            },
            callback: {
                beforeClick: function () {                                      // 节点不可选择
                    return false;
                },
                onClick: function (event, treeId, treeNode) {

                },
                onAsyncSuccess: function () {

                },
                beforeDrag: function () {                                         // 开始移动之前触发的事件， 返回值决定是否可以开始移动,
                    return false;
                },
                beforeDragOpen: function () {
                },                                   // 移动到折叠节点打开之前的事件
                beforeDrop: function () {
                },                                       // 结束移动之前触发的事件， 返回值决定是否可以完成移动
                // 移动完成事件
                onDrop: function (event, treeIdString, treeNodes, targetNode, moveType, isCopy) {

                }
            },
            view: {
                dblClickExpand: false,                                            // 双击节点时，是否自动展开父节点的标识
                showLine: true,                                                   // 是否显示节点之间的连线。
                selectedMulti: false,                                             // 是否允许同时选中多个节点。
                txtSelectedEnable: false,                                         // 是否允许可以选择 zTree DOM 内的文本。
                addHoverDom: function () {                                        // 鼠标移入显示自定义控件
                },
                removeHoverDom: function () {                                     // 鼠标移出隐藏自定义控件
                }
            },
            data: {
                key: {
                    checked: "checkFlag",                                           // 节点数据中保存 check 状态的属性名称。
                    children: "sub",                                                // 节点数据中保存子节点数据的属性名称。
                    name: "name",                                                   // 节点数据保存节点名称的属性名称
                    url: null                                                       // 点数据保存节点链接的目标 URL 的属性名称。
                },
                simpleData: {                                                        // 数据是否采用简单数据模式 (Array)
                    enable: true,                                                   // 数据是否采用简单数据模式 (Array)
                    idKey: "id",                                                     // 节点数据中保存唯一标识的属性名称
                    pIdKey: "pid",                                                  // 节点数据中保存其父节点唯一标识的属性名称。
                    rootPId: null                                                   // 用于修正根节点父节点数据，即 pIdKey 指定的属性值。
                }
            }
        };
        let opt = $.extend(true, defaults, options);

        // 树结构初始化加载
        var setting = {
            callback: {
                beforeClick:options.beforeClick,
                onClick: options.onClick,                      // 用于捕获节点被点击的事件回调函数
                onCheck: options.onCheck,                      // 用于捕获 checkbox / radio 被勾选 或 取消勾选的事件回调函数
                onDblClick: options.onDblClick                 // 用于捕获鼠标双击之后的事件回调函数
            }
        };
        let optt = $.extend(true, opt, setting);
        return $.fn.zTree.init($("#" + optt.id), optt, null);
    },
    /**
     * 请求数据处理
     * @param treeId
     * @param parentNode
     * @param responseData
     * @returns {Array}
     */
    ajaxDataFilter: function (treeId, parentNode, responseData) {
        return responseData;
    },
    /**
     * 获取当前被勾选集合
     * @returns {*}
     */
    getCheckedNodes: function (tree) {
        let nodes = tree.getCheckedNodes(true);
        return $.map(nodes, function (node) {
            return node.id;
        });
    },
    /**
     * 移除节点
     * @param tree
     * @param node
     */
    remove: function (tree, node) {
        tree.removeNode(node);
    },
    /**
     * 刷新树
     */
    refresh: function (tree) {
        tree.reAsyncChildNodes(null, "refresh");
    },
    /**
     * 取消选中
     * @param tree
     * @param node
     */
    cancelSelect: function (tree, node) {
        tree.cancelSelectedNode(node);
    },
    /** 展开/折叠树 */
    expandAll: function (tree, bool) {
        tree.expandAll(bool);
    }
},
hot: {
    _hot: {},
    _option: {},
    _allData: {},                                               // 所有数据
    _updateData: [],                                            // 更新的数据
        _delData: [],                                               // 删除行的 id 数组
        _insertData: [],                                            // 新增的数据
        /**
         * 初始化表格
         * @param options 配置信息
         */
        init: function (options) {
        let defaults = {
            element: $("#hot")[0],                              // 默认元素
            saveButtonId: $("#btn-save"),                           // 保存按钮ID
            licenseKey: 'non-commercial-and-evaluation',
            className: 'htCenter htMiddle',               //对齐方式 水平: htLeft, htCenter, htRight, htJustify 重直: htTop, htMiddle, htBottom
            language: 'zh-CN',
            stretchH: 'all',                                    // last:延伸最后一列, all:延伸所有列, none默认不延伸。
            width: '100%',                                      // 表格宽度
            height: 650,                                        // 表格高度
            minRows: 0,                                         // 最小行数
            minSpareRows: 0,                                    // 数据不到最小行数用空行补充
            data: {},                                           // 数据
            colHeaders: [],                                     // 表格头数组
            fieldName: [],                                      // 列字段名
            columns: [],                                        // 表格列
            hiddenColumns: {                                    // 隐藏列， 默认第1列 id 列隐藏
                columns: [0],
                indicators: true
            },
            rowHeaders: true,                                   // 行序号
            columnSorting: true,                                // 列排序
            autoColumnSize: true,                               // 自动列宽
            contextMenu: true,                                  // 右键表头菜单
            manualRowResize: true,                              // 拖拽行头改变大小
            manualColumnResize: true,                           // 拖拽列头改变大小
            manualRowMove: true,                                // 拖拽行移动
            manualColumnMove: true,                             // 拖拽列移动
            filters: true,                                      // 过滤
            dropdownMenu: true,                                 // 下拉菜单
            fixedRowsTop: 0,                                    // 固定行 值为行数而不是索引
            fixedRowsBottom: 0,                                 // 固定行 从底部开始
            fixedColumnsLeft: 0,                                // 固定列 从左侧开始
            allowInsertColumn: true,                            // 允许插入列
            allowInsertRow: true,                               // 允许插入行
            allowInvalid: true,                                 // 是否允许存在无效值
            allowRemoveColumn: true,                            // 允许删除列
            allowRemoveRow: true,                               // 允许删除行
            beforeRemoveRow: function (index, amount) {         // 删除行时执行， 参数 index 第一行索引， amount 行数
                if (js.hot._option.removeCallBack) {
                    js.hot._option.removeCallBack(index, amount);
                }
                // 封装id成array传入后台
                if (amount !== 0) {
                    for (let i = index; i < amount + index; i++) {
                        let rowdata = js.hot._hot.getDataAtRow(i);
                        if (rowdata[0] != null) {
                            js.hot._delData.push(rowdata[0]);
                        }
                    }
                }
            },
            afterChange: function (changes, source) {           // 修改后执行
                //params 参数 1.column num , 2,id, 3,oldvalue , 4.newvalue
                let params = [];
                if (changes != null) {
                    let index = changes[0][0];//行号码
                    let rowdata = js.hot._hot.getDataAtRow(index);
                    params.push(rowdata[0]);
                    params.push(changes[0][1]);
                    params.push(changes[0][2]);
                    params.push(changes[0][3]);
                    //仅当单元格发生改变的时候,id!=null,说明是更新
                    if (params[2] !== params[3] && params[0] != null) {
                        let data = {};
                        $.each(js.hot._option.fieldName, function (index, name) {
                            data[name] = rowdata[index];
                        });
                        // 判断记录是否存在,更新数据
                        let flag = true;
                        $.each(js.hot._updateData, function (index, node) {
                            if (node.id === data.id) {
                                flag = false;
                                //用新得到的记录替换原来的,不用新增
                                js.hot._updateData[index] = data;
                            }
                        });
                        // 没有更新则添加
                        flag && js.hot._updateData.push(data);
                    }
                    if (js.hot._option.customChange) {
                        js.hot._option.customChange(index, params[1], rowdata);
                    }
                }
            }
        };
        js.hot._option = $.extend(defaults, options);
        js.hot._hot = new Handsontable(js.hot._option.element, js.hot._option);
        /*
        移除监听事件
         */
        // js.hot._option.saveButtonId.removeEventListener("click",js.hot._f,false);
        //先解除绑定
        js.hot._option.saveButtonId.unbind('click').click(function () {
            js.hot._hot.validateCells(function (valid) {
                if (!valid) {
                    js.modal.warning("数据有误，无法提交！");
                } else {
                    //所有的id
                    let ids = js.hot._hot.getDataAtCol(0);
                    //------------2020/3/20 TH清空insertData-----------------
                    js.hot._insertData = [];
                    //---------------------------------------------------
                    for (let i = 0; i < ids.length; i++) {
                        //id=null时,是插入数据,此时的i正好是行号
                        if (ids[i] == null && !js.hot._hot.isEmptyRow(i)) {
                            //获得id=null时的所有数据封装进data
                            let rowdata = js.hot._hot.getDataAtRow(i);
                            //let collength = hot.countCols();
                            if (rowdata != null) {
                                let data = {};
                                $.each(js.hot._option.fieldName, function (index, name) {
                                    data[name] = rowdata[index];
                                });
                                js.hot._insertData.push(data);
                            }
                        }
                    }
                    if (js.hot._insertData.length > 0) {
                        js.hot._allData.insertData = js.hot._insertData;
                    }
                    // 如果更新的数据与删除的数据项同时存在， 则按删除处理
                    if (js.hot._updateData.length !== 0 && js.hot._delData.length !== 0) {
                        for (let i = 0; i < js.hot._delData.length; i++) {
                            for (let j = 0; j < js.hot._updateData.length; j++) {
                                if (js.hot._updateData[j].id === js.hot._delData[i]) {
                                    js.hot._updateData.splice(j, 1);
                                }
                            }
                        }
                    }
                    //封装
                    if (js.hot._updateData.length > 0) {
                        js.hot._allData.updateData = js.hot._updateData;
                    }
                    if (js.hot._delData.length > 0) {
                        js.hot._allData.delData = js.hot._delData;
                    }
                    //
                    if (js.hot._option.formData) {
                        let fd = {};
                        $.each(js.hot._option.formData, function (i, v) {
                            if ($("#" + v).val() !== '') {
                                fd[v] = $("#" + v).val();
                            }
                        });
                        if (JSON.stringify(fd) !== "{}") {
                            js.hot._allData.formData = fd;
                        }
                    }
                    if (js.hot._option.callBack) {
                        js.hot._option.callBack(js.hot._allData);
                    } else if (js.hot._option.url) {
                        if (JSON.stringify(js.hot._allData) !== "{}") {
                            js.post({
                                url: js.hot._option.url,
                                data: JSON.stringify(js.hot._allData),
                                contentType: "application/json",
                                success: function (result) {
                                    if (result.type === web_status.SUCCESS) {
                                        js.modal.success(result.msg);
                                        js.hot._allData = {};
                                        js.hot._updateData = [];
                                        js.hot._delData = [];
                                        js.hot._insertData = [];
                                    } else {
                                        js.modal.warning(result.msg);
                                    }
                                    js.modal.closeLoading();
                                }
                            });
                        } else {
                            js.modal.warning("没有需要处理的数据，保存未执行！");
                        }
                    }
                }
            });
        });
    },
    /**
     * 加载表格数据
     * @param data 表格数据
     */
    loadData: function (data) {
        js.hot._hot.loadData(data);
    },
    /**
     * 获取表格数据
     */
    getData: function () {
        js.hot._hot.getData();
    },
    /**
     * 销毁
     */
    destroy: function () {
        if (!$.isEmptyObject(js.hot._hot)) {
            js.hot._hot = {};
        }
    }
},
ws: {
    _ws: {},
    init: function (options) {
        if (typeof (WebSocket) === "undefined") {
            alert("您的浏览器不支持消息推送，无法实时收到系统消息");
        } else {
            js.ws._ws = new WebSocket(options.url);
            js.ws._ws.onopen = function () {
            };
            js.ws._ws.onmessage = function (msg) {
                options.handler(msg);
            };
            js.ws._ws.onclose = function () {
            };
            js.ws._ws.onerror = function () {
            };
        }
    }
},
/**加法函数，用来得到精确的加法结果
 @说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
 @调用：js.additiveoperationFun(arg1,arg2)
 @param arg1 arg2 相加的两个数
 @返回值：arg1加上arg2的精确结果**/
additiveoperationFun: function (arg1, arg2) {
    let r1, r2, m;
    try {
        r1 = arg1.toString().split(".")[1].length
    } catch (e) {
        r1 = 0
    }
    try {
        r2 = arg2.toString().split(".")[1].length
    } catch (e) {
        r2 = 0
    }
    m = Math.pow(10, Math.max(r1, r2));
    return (arg1 * m + arg2 * m) / m
},
/**
 @说明：过滤掉HTML破坏性标签符号。
 @调用：js.html2Escape(sHtml)
 @param sHtml 被过滤的的字符串参数
 @返回值：返回被处理后的字符串**/
html2Escape: function (sHtml) {
    return sHtml.replace(/[<>&"]/g, function (c) {
        return {
            '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;'
        }[c];
    });
},
/**
 * 将数值四舍五入(保留2位小数)后格式化成金额形式
 *
 * @param num 数值(Number或者String)
 * @return 金额格式的字符串,如'1,234,567.45'
 * @type String
 */
formatMoney: function (num) {
    let unit = "";
    if (num.toString().indexOf("万元") > 0) {
        unit = "万元";
        num = num.replace('万元', '');
    } else if (num.toString().indexOf("元") > 0) {
        unit = "元";
        num = num.replace('元', '');
    }
    num = num.toString().replace(/\$|\,/g, '');
    if (isNaN(num))
        num = "0";
    sign = (num == (num = Math.abs(num)));
    num = Math.floor(num * 100 + 0.50000000001);
    cents = num % 100;
    num = Math.floor(num / 100).toString();
    if (cents < 10)
        cents = "0" + cents;
    for (let i = 0; i < Math.floor((num.length - (1 + i)) / 3); i++)
        num = num.substring(0, num.length - (4 * i + 3)) + ',' +
            num.substring(num.length - (4 * i + 3));
    return (((sign) ? '' : '-') + num + '.' + cents) + unit;
},
/**
 * 将数值四舍五入(保留1位小数)后格式化成金额形式
 *
 * @param num 数值(Number或者String)
 * @return 金额格式的字符串,如'1,234,567.4'
 * @type String
 */
formatCurrency: function (num) {
    num = num.toString().replace(/\$|\,/g, '');
    if (isNaN(num))
        num = "0";
    sign = (num == (num = Math.abs(num)));
    num = Math.floor(num * 10 + 0.50000000001);
    cents = num % 10;
    num = Math.floor(num / 10).toString();
    for (let i = 0; i < Math.floor((num.length - (1 + i)) / 3); i++)
        num = num.substring(0, num.length - (4 * i + 3)) + ',' +
            num.substring(num.length - (4 * i + 3));
    return (((sign) ? '' : '-') + num + '.' + cents);
},
/**
 * 数据金额的验证
 * @param s
 * @returns {boolean}
 */
isNumber: function (s) {
    let regu = "^[0-9]+\.?[0-9]*$";
    let re = new RegExp(regu);
    if (re.test(s)) {
        return true;
    } else {
        return false;
    }
},
/** 打印 */
print: function print(id_str) {
    let el = document.getElementById(id_str);
    let iframe = document.createElement('IFRAME');
    let doc = null;
    iframe.setAttribute('style', 'position:absolute;width:0px;height:0px;left:-500px;top:-500px;');
    document.body.appendChild(iframe);
    doc = iframe.contentWindow.document;
    doc.write('<p>' + el.innerHTML + '</p>');
    doc.close();
    iframe.contentWindow.focus();
    iframe.contentWindow.print();
    if (navigator.userAgent.indexOf("MSIE") > 0) {
        document.body.removeChild(iframe);
    }
},
/** 日期控件初始化 */
datePicker: function () {
    $('.datepicker').datepicker({
        format: 'yyyy-mm-dd',
        language: 'zh-cn',
        autoclose: true,
        clearBtn: true
    }).on('hide', function (event) {
        event.stopPropagation();
    });
},
/** 根据文本框值设置日期 */
updateDatePicker: function () {
    $('.datepicker').datepicker('update');
},
select2: function (options) {
    let defaults = {
        id: 'select2',
        minimumInputLength:4,
        ajax: {
            delay: 250,
            type:'get',
            url: function(){
                return ''
            },
            dataType:'json',
            data: function(params) {
                return {
                    q: params.term,
                }
            },
            processResults: function (data, page) {
                return { results: data };
            },
            cache: true,
        },
        placeholder:'请选择',
        escapeMarkup: function(markup) {
            return markup
        },
        language: {
            noResults: function() {
                return '未找到匹配选项'
            },
            inputTooShort: function (args) {
                let remainingChars = args.minimum - args.input.length;
                return '请输入' + remainingChars + '个或更多文字';
            },
            searching: function () {
                return '搜索中…';
            }
        }
    };
    let opt = $.extend(defaults, options);
    return $("#" + opt.id).select2(opt);
},
/** 验证 */
vd: function (option) {
    let defaults = {
        id: "form",
    };
    let opt = $.extend(defaults, option);
    let that = $("#" + opt.id);
    if (opt.notEmpty instanceof Array) {
        opt.notEmpty.forEach(value => {
            let target = that.find(`[name=${value}]`);
        target.each(function (i,v) {
            if ($.trim($(this).val()) === '') {
                $(this).addClass('vd-error');
                $(this).css('border', '1px solid #FF3333');
            } else {
                $(this).removeClass('vd-error');
                $(this).css('border', 'none');
            }
        })
    })
    }
    return that.find(".vd-error").length === 0
},
/** 格式化小数 */
format: function (n, b) {
    /*if (n != null || n != undefined) {
        n = String(n).replace(/^(.*\..{2}).*$/, "$1");
        n = Number(n); // number = 12.3321
        if (String(n).indexOf('.') > 0 && String(n).substring(String(n).indexOf('.')).length > b) {
            n = Number(n).toFixed(b);
        }
        return n;
    } else {
        return n;
    }*/
    if (n) {
        return String(n).replace(/^(.*\..{2}).*$/, "$1");
    }
    return n;
},
/** 处理<br> 空格 */
textToValue : function toTextarea(str){
    let reg=new RegExp("<br>","g");
    let regSpace=new RegExp("&ensp;","g");
    str = str.replace(reg,"\n");
    str = str.replace(regSpace," ");
    return str;
}
};

/** 防止重复点击 */
$.fn.repeatClick = function () {
    let $this = $(this);
    $this.attr('disabled', true);
    setTimeout(function () {
        $this.removeAttr('disabled');
    }, 500);
    return $this;
};

/**
 * 使元素跟随页面滚动
 * @returns {*|HTMLElement}
 */
$.fn.customScroll = function () {
    let element = $(this);
    let top = element.position().top;
    element.css({position: "relative"});
    $(window).scroll(function () {
        let scrolls = $(this).scrollTop();
        if (scrolls > top) {
            element.css({top: scrolls});
        } else {
            element.css({top: top});
        }
    });
    return element;
};

let defaultSetting = {
    prefix: ''
};

/**
 * 生成 setting，合并 defaultSetting 与 setting
 */
function generateSetting(setting) {
    setting = ($.type(setting) === 'object' && !$.isEmptyObject(setting)) ? setting : {};
    return $.extend({}, defaultSetting, setting);
}

/**
 * 生成 Json key，移除 name 的前缀和后缀
 */
function generateKey(name, setting) {
    // 前缀不为空时，移除前缀
    if (setting.prefix !== '') {
        name = name.replace(setting.prefix, '');
    }
    return name;
}

/**
 * 填充span span[id] = json.key
 * @param jsonData json数据
 * @param setting 设置
 * @returns {*|HTMLElement}
 */
$.fn.fillSpan = function (jsonData, setting) {
    // 获取表单元素
    let formElements = $(this).find("span");
    // 参数设置
    setting = generateSetting(setting);

    // 传入的json数据非空时
    if (jsonData && $.type(jsonData) === 'object' && !$.isEmptyObject(jsonData)) {

        let repeatJson = {};

        // 遍历容器内所有表单元素
        formElements.each(function () {
            // 表单元素名称
            let name = $(this).attr("id");
            if (!name) {
                return true;
            }
            // jsonData key 值（移除 name 的前缀和后缀）
            let key = generateKey(name, setting);

            if (repeatJson[name]) {
                return true;
            }

            if (jsonData.hasOwnProperty(key)) {
                $(this).text(jsonData[key]);
                repeatJson[name] = true;
            }
        });
    }
    return $(this);
};

/**
 * 填充表单 表单标签name = json.key
 * @param jsonData json 数据
 * @param setting 设置
 * @returns {*|HTMLElement}
 */
$.fn.fillData = function (jsonData, setting) {
    // 获取表单元素
    let formElements = $(this).find(":input:not(:file):not(:image):not(:reset):not(:button):not(:submit)[name]");
    // 参数设置
    setting = generateSetting(setting);

    // 传入的json数据非空时
    if (jsonData && $.type(jsonData) === 'object' && !$.isEmptyObject(jsonData)) {

        let repeatJson = {};

        // 遍历容器内所有表单元素
        formElements.each(function () {
            // 表单元素名称
            let name = $(this).attr("name");
            if (!name) {
                return true;
            }
            // jsonData key 值（移除 name 的前缀和后缀）
            let key = generateKey(name, setting);

            if (repeatJson[name]) {
                return true;
            }

            if (jsonData.hasOwnProperty(key)) {
                // 当表单元素为 radio 时
                if ($(this).is(":radio")) {
                    // 取消 radio 选中状态
                    formElements.filter(":radio[name='" + name + "']").prop("checked", false);
                    // 选中 radio
                    formElements.filter(":radio[name='" + name + "'][value=" + jsonData[key] + "]").prop("checked", true);
                }
                // 当表单元素为 checkbox 时
                else if ($(this).is(":checkbox")) {
                    // 取消 checkbox 选中状态
                    formElements.filter(":checkbox[name='" + name + "']").prop("checked", false);
                    let checkBoxData = jsonData[key];
                    if ($.type(checkBoxData) === 'array') {
                        $.each(checkBoxData, function (i, val) {
                            formElements.filter(":checkbox[name='" + name + "'][value=" + val + "]").prop("checked", true);
                        });
                    } else if ($.type(checkBoxData) === 'string') {
                        $.each(checkBoxData.split(setting.separator), function (i, val) {
                            formElements.filter(":checkbox[name='" + name + "'][value=" + val + "]").prop("checked", true);
                        });
                    } else {
                        formElements.filter(":checkbox[name='" + name + "'][value=" + checkBoxData + "]").prop("checked", true);
                    }
                }
                // 其他情况
                else {
                    $(this).val(jsonData[key]);
                }

                repeatJson[name] = true;
            }
        });
    }
    return $(this);
};

/**
 * 序列化表单为JSON对象
 */
$.fn.serializeObject = function() {
    let o = {};
    let a = this.serializeArray();
    $.each(a, function() {
        if (o[this.name]) {
            if (!o[this.name].push) {
                o[this.name] = [o[this.name]];
            }
            o[this.name].push(this.value || '');
        } else {
            o[this.name] = this.value || '';
        }
    });
    return o;
};

/**
 * 日期格式化
 * @param format
 * @returns {*}
 */
Date.prototype.format = function (format) {
    let args = {
        "M+": this.getMonth() + 1,
        "d+": this.getDate(),
        "h+": this.getHours(),
        "m+": this.getMinutes(),
        "s+": this.getSeconds(),
        "q+": Math.floor((this.getMonth() + 3) / 3),  //quarter
        "S": this.getMilliseconds()
    };
    if (/(y+)/.test(format)) {
        format = format.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
    }
    for (let i in args) {
        let n = args[i];
        if (new RegExp("(" + i + ")").test(format)) {
            format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? n : ("00" + n).substr(("" + n).length));
        }
    }
    return format;
};

/**
 * 星期
 */
Date.prototype.week = function () {
    let weeks = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"];
    return weeks[this.getDay()];
};

/**
 * 数组去重
 * @returns {Array}
 */
Array.prototype.distinct = function () {
    let new_arr = [];
    for (let i = 0; i < this.length; i++) {
        let items = this[i];
        if ($.inArray(items, new_arr) === -1) {
            new_arr.push(items);
        }
    }
    return new_arr;
};

/**
 * 返回顶部
 */
js.goTop();

/** 判断极速模式 */
if (window.navigator.userAgent.indexOf('AppleWebKit') === -1) {
    js.modal.open("modal-alert360");
}

js.modal.hideEvent("modal-alert360", function () {
    window.opener = null;
    window.open('', '_self');
    window.close();
});

js.datePicker();

/**
 * 回车触发搜索按钮
 */
js.enter("btn-search");

$(".select2").select2();

$("input,textarea").on('paste keyup', function () {
    $(this).val($(this).val().replace(/,/g, '，'));
});

function returnMaterialWeight(materialSpec,materialLength,materialWidth,materialHeight,ityNum,matFormulaType) {

    let totalWeight;
    if (matFormulaType == 1) {
        // （规格*宽度*长度*数量*7.85/1000）-（(规格-2*米重/厚度)*（宽度-2*米重/厚度）*7.85/1000*数量*长度）
        totalWeight = (materialSpec * materialWidth * materialLength * ityNum * 7.85 / 1000) - ((materialSpec - 2 * materialHeight) * (materialWidth - 2 * materialHeight) * 7.85 / 1000 * ityNum * materialLength);
    }
    if (matFormulaType == 2) {
        // 规格*规格*长度*数量*0.00617
        totalWeight = materialSpec * materialSpec * materialLength * ityNum * 0.00617;
    }
    if (matFormulaType == 3) {
        // 长度*数量*米重/厚度
        totalWeight = materialLength * ityNum * materialHeight;
    }
    if (matFormulaType == 4) {
        // （规格-宽度）*宽度*0.02466*长度*数量
        totalWeight = (materialSpec - materialWidth) * materialWidth * 0.02466 * materialLength * ityNum;
    }
    if (matFormulaType == 5) {
        // 规格*宽度*长度*2.7/1000000*数量
        totalWeight = materialSpec * materialWidth * materialLength * 2.7 / 1000000 * ityNum;
    }
    if (matFormulaType == 6) {
        // 规格*宽度*长度*7.85/1000000*数量
        totalWeight = materialSpec * materialWidth * materialLength * 7.85 / 1000000 * ityNum;
    }
    if (matFormulaType == undefined) {
        totalWeight = 0;
    }
    return totalWeight.toFixed(2);
}
/*
  根据计算公式，计算原料金额
 */
function returnMaterialAmount(ityWeight,ityPrice){

    let totalAmount = ityPrice * ityWeight;

    return totalAmount.toFixed(2);
}

function toUtf8(str) {
    var out, i, len, c;
    out = "";
    len = str.length;
    for (i = 0; i < len; i++) {
        c = str.charCodeAt(i);
        if ((c >= 0x0001) && (c <= 0x007F)) {
            out += str.charAt(i);
        } else if (c > 0x07FF) {
            out += String.fromCharCode(0xE0 | ((c >> 12) & 0x0F));
            out += String.fromCharCode(0x80 | ((c >> 6) & 0x3F));
            out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));
        } else {
            out += String.fromCharCode(0xC0 | ((c >> 6) & 0x1F));
            out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));
        }
    }
    return out;
}